home *** CD-ROM | disk | FTP | other *** search
/ Mac Format 1994 October / Macformat17.cdr / Shareware City / Developers / MacVogl-alpha1PPC / queue.c < prev    next >
C/C++ Source or Header  |  1994-07-11  |  8KB  |  401 lines
  1. #include <stdio.h>
  2. #include "vogl.h"
  3. #include "vodevice.h"
  4.  
  5. /*
  6.  * qdevice
  7.  *
  8.  *    enable an input device.
  9.  */
  10. void
  11. qdevice(dev)
  12.     Device    dev;
  13. {
  14.     int    i;
  15.  
  16.     if (!vdevice.initialised)
  17.         verror("qdevice: vogl not initialised\n");
  18.  
  19.     if (dev > (Device)MAXDEV)
  20.         verror("qdevice: bad device number passed\n");
  21.  
  22.     switch (dev) {
  23.     case AKEY:
  24.     case BKEY:
  25.     case CKEY:
  26.     case DKEY:
  27.     case EKEY:
  28.     case FKEY:
  29.     case GKEY:
  30.     case HKEY:
  31.     case IKEY:
  32.     case JKEY:
  33.     case KKEY:
  34.     case LKEY:
  35.     case MKEY:
  36.     case NKEY:
  37.     case OKEY:
  38.     case PKEY:
  39.     case QKEY:
  40.     case RKEY:
  41.     case SKEY:
  42.     case TKEY:
  43.     case UKEY:
  44.     case VKEY:
  45.     case WKEY:
  46.     case XKEY:
  47.     case YKEY:
  48.     case ZKEY:
  49.         vdevice.kbdevents = 1;
  50.         vdevice.enabled[dev / 8] |= 1 << (dev & 0x7);
  51.         vdevice.enabled[(dev - 'A' + 'a') / 8] |= 1 << ((dev - 'A' + 'a') & 0x7);
  52.         break;
  53.     case KEYBD:
  54.         vdevice.kbdmode = 1;
  55.         vdevice.kbdevents = 1;
  56.         for (i = 0; i != MAXDEVTABSIZE; i++)
  57.             vdevice.enabled[i] = 0xff;
  58.  
  59.         vdevice.enabled[0] &= 0xfe;    /* make sure 0 disabled for qtest */
  60.         break;
  61.     case MOUSE1:
  62.     case MOUSE2:
  63.     case MOUSE3:
  64.         vdevice.mouseevents = 1;
  65.         vdevice.enabled[dev / 8] |= 1 << (dev & 0x7);
  66.         break;
  67.     case MINUSKEY:
  68.         vdevice.kbdevents = 1;
  69.         vdevice.enabled['-' / 8] |= 1 << ('-' & 0x7);
  70.         vdevice.enabled['_' / 8] |= 1 << ('_' & 0x7);
  71.         break;
  72.     case BACKSLASHKEY:
  73.         vdevice.kbdevents = 1;
  74.         vdevice.enabled['\\' / 8] |= 1 << ('\\' & 0x7);
  75.         vdevice.enabled['|' / 8] |= 1 << ('|' & 0x7);
  76.         break;
  77.     case EQUALKEY:
  78.         vdevice.kbdevents = 1;
  79.         vdevice.enabled['=' / 8] |= 1 << ('=' & 0x7);
  80.         vdevice.enabled['+' / 8] |= 1 << ('+' & 0x7);
  81.         break;
  82.     case LEFTBRACKETKEY:
  83.         vdevice.kbdevents = 1;
  84.         vdevice.enabled['[' / 8] |= 1 << ('[' & 0x7);
  85.         vdevice.enabled['{' / 8] |= 1 << ('{' & 0x7);
  86.         break;
  87.     case RIGHTBRACKETKEY:
  88.         vdevice.kbdevents = 1;
  89.         vdevice.enabled[']' / 8] |= 1 << (']' & 0x7);
  90.         vdevice.enabled['}' / 8] |= 1 << ('}' & 0x7);
  91.         break;
  92.     case REDRAW:        /* do nothing */
  93.     case INPUTCHANGE:
  94.         break;
  95.     default:
  96.         vdevice.kbdevents = 1;
  97.         vdevice.enabled[dev / 8] |= 1 << (dev & 0x7);
  98.     }
  99. }
  100.  
  101. /*
  102.  * unqdevice
  103.  *
  104.  *    disable an input device.
  105.  */
  106. void
  107. unqdevice(dev)
  108.     Device    dev;
  109. {
  110.     int    i;
  111.  
  112.     if (!vdevice.initialised)
  113.         verror("qdevice: vogl not initialised\n");
  114.  
  115.     if (dev > (Device)MAXDEV)
  116.         verror("qdevice: bad device number passed\n");
  117.  
  118.     switch (dev) {
  119.     case AKEY:
  120.     case BKEY:
  121.     case CKEY:
  122.     case DKEY:
  123.     case EKEY:
  124.     case FKEY:
  125.     case GKEY:
  126.     case HKEY:
  127.     case IKEY:
  128.     case JKEY:
  129.     case KKEY:
  130.     case LKEY:
  131.     case MKEY:
  132.     case NKEY:
  133.     case OKEY:
  134.     case PKEY:
  135.     case QKEY:
  136.     case RKEY:
  137.     case SKEY:
  138.     case TKEY:
  139.     case UKEY:
  140.     case VKEY:
  141.     case WKEY:
  142.     case XKEY:
  143.     case YKEY:
  144.     case ZKEY:
  145.         vdevice.enabled[dev / 8] &= ~(1 << (dev & 0x7));
  146.         vdevice.enabled[(dev - 'A' + 'a') / 8] &= ~(1 << ((dev - 'A' + 'a') & 0x7));
  147.         break;
  148.     case KEYBD:
  149.         vdevice.kbdmode = 0;
  150.         for (i = 0; i != MAXDEVTABSIZE; i++)
  151.             vdevice.enabled[i] = 0x00;
  152.         break;
  153.     case MOUSE1:
  154.     case MOUSE2:
  155.     case MOUSE3:
  156.         vdevice.enabled[dev / 8] &= ~(1 << (dev & 0x7));
  157.         break;
  158.     case MINUSKEY:
  159.         vdevice.enabled['-' / 8] &= ~(1 << ('-' & 0x7));
  160.         vdevice.enabled['_' / 8] &= ~(1 << ('_' & 0x7));
  161.         break;
  162.     case BACKSLASHKEY:
  163.         vdevice.enabled['\\' / 8] &= ~(1 << ('\\' & 0x7));
  164.         vdevice.enabled['|' / 8] &= ~(1 << ('|' & 0x7));
  165.         break;
  166.     case EQUALKEY:
  167.         vdevice.enabled['=' / 8] &= ~(1 << ('=' & 0x7));
  168.         vdevice.enabled['+' / 8] &= ~(1 << ('+' & 0x7));
  169.         break;
  170.     case LEFTBRACKETKEY:
  171.         vdevice.enabled['[' / 8] &= ~(1 << ('[' & 0x7));
  172.         vdevice.enabled['{' / 8] &= ~(1 << ('{' & 0x7));
  173.         break;
  174.     case RIGHTBRACKETKEY:
  175.         vdevice.enabled[']' / 8] &= ~(1 << (']' & 0x7));
  176.         vdevice.enabled['}' / 8] &= ~(1 << ('}' & 0x7));
  177.         break;
  178.     case REDRAW:        /* do nothing */
  179.     case INPUTCHANGE:
  180.         return;
  181.     default:
  182.         vdevice.enabled[dev / 8] &= ~(1 << (dev & 0x7));
  183.     }
  184.  
  185.     vdevice.mouseevents = vdevice.kbdevents = 0;
  186.  
  187.     for (i = 0; i != MAXDEVTABSIZE; i++)
  188.         if (vdevice.enabled[i] != 0) {
  189.             if (i < 32)        /* max bits for keyboard */
  190.                 vdevice.kbdevents = 1;
  191.             else                /* must be mouse */
  192.                 vdevice.mouseevents = 1;
  193.         }
  194. }
  195.  
  196. /*
  197.  * qread
  198.  *
  199.  *    a poor man's qread, we only have a device queue one deep.
  200.  * Just sit and poll in case something happens. If nothing is
  201.  * enabled or there are no devices this returns -1.
  202.  */
  203. long
  204. qread(ret)
  205.     short    *ret;
  206. {
  207.     int    a, b, c1, c2, val;
  208.     int    eventind, eventmask, retvalue;
  209.  
  210.     if (!vdevice.initialised)
  211.         verror("qread: vogl not initialised\n");
  212.  
  213.     if (vdevice.alreadyread) {
  214.         *ret = vdevice.data;
  215.         if (!vdevice.kbdmode && vdevice.data == 1)
  216.             vdevice.data = 0;
  217.         else
  218.             vdevice.alreadyread = 0;
  219.         return(vdevice.devno);
  220.     }
  221.  
  222.     val = c1 = c2 = 0;
  223.  
  224.     eventind = 0;
  225.     eventmask = 0;
  226.  
  227.     if (!vdevice.mouseevents && vdevice.kbdevents) {
  228.         while (!(vdevice.enabled[eventind] & eventmask)) {
  229.             if ((val = c1 = (*vdevice.dev.Vgetkey)()) < 0)
  230.                 return(val);
  231.  
  232.             eventind = c1 / 8;
  233.             eventmask = 1 << (c1 & 0x7);
  234.             *ret = c1;
  235.             if (c1 >= 'a' && c1 <= 'z')
  236.                 retvalue = c1 - 'a' + 'A';
  237.             else
  238.                 retvalue = c1;
  239.         }
  240.     } else if (vdevice.mouseevents && !vdevice.kbdevents) {
  241.         while (!(vdevice.enabled[eventind] & eventmask)) {
  242.             if ((c2 = (*vdevice.dev.Vlocator)(&a, &b)) < 0)
  243.                 return(c2);
  244.  
  245.             if (c2 != 0) {
  246.                 if (c2 & 0x01)
  247.                     c2 = MOUSE3;
  248.                 else if (c2 & 0x02)
  249.                     c2 = MOUSE2;
  250.                 else if (c2 & 0x04)
  251.                     c2 = MOUSE1;
  252.  
  253.                 eventind = c2 / 8;
  254.                 eventmask = 1 << (c2 & 0x7);
  255.                 *ret = c2;
  256.                 retvalue = c2;
  257.             }
  258.         }
  259.     } else if (vdevice.mouseevents && vdevice.kbdevents) {
  260.         while (!(vdevice.enabled[eventind] & eventmask)) {
  261.             while (c1 == 0 && c2 == 0) {
  262.                 val = c1 = (*vdevice.dev.Vcheckkey)();
  263.  
  264.                 c2 = (*vdevice.dev.Vlocator)(&a, &b);
  265.             }
  266.  
  267.             if (c1 < 0 && c2 < 0)
  268.                 return(-1);
  269.  
  270.             if (c1 != 0) {
  271.                 eventind = c1 / 8;
  272.                 eventmask = 1 << (c1 & 0x7);
  273.                 *ret = c1;
  274.                 if (c1 >= 'a' && c1 <= 'z')
  275.                     retvalue = c1 - 'a' + 'A';
  276.                 else
  277.                     retvalue = c1;
  278.             } else {
  279.                 if (c2 & 0x01)
  280.                     c2 = MOUSE3;
  281.                 else if (c2 & 0x02)
  282.                     c2 = MOUSE2;
  283.                 else if (c2 & 0x04)
  284.                     c2 = MOUSE1;
  285.                 eventind = c2 / 8;
  286.                 eventmask = 1 << (c2 & 0x7);
  287.                 *ret = c2;
  288.                 retvalue = c2;
  289.             }
  290.         }
  291.     } else
  292.         return(-1);
  293.  
  294.     if (vdevice.kbdmode && val != 0) {
  295.         *ret = val;
  296.         return(KEYBD);
  297.     } else {
  298.         *ret = 1;            /* insert the up event */
  299.         vdevice.data = 0;
  300.         vdevice.devno = retvalue;
  301.         vdevice.alreadyread = 1;
  302.     }
  303.  
  304.     return(retvalue);
  305. }
  306.  
  307. /*
  308.  * qreset
  309.  *
  310.  *    as the queue is rather short this is easy.
  311.  */
  312. void
  313. qreset()
  314. {
  315.     while (((*vdevice.dev.Vcheckkey)()))
  316.         ;
  317.  
  318.     vdevice.alreadyread = 0;
  319. }
  320.  
  321. /*
  322.  * qtest
  323.  *
  324.  *    Check if there is anything in the event queue. As our reads are
  325.  * destructive at the moment, we have to save what we get in the device
  326.  * structure.
  327.  */
  328. long
  329. qtest()
  330. {
  331.     int    a, b, c1, c2, val;
  332.     int    eventind, eventmask;
  333.  
  334.     if (!vdevice.initialised)
  335.         verror("qtest: vogl not initialised\n");
  336.  
  337.     eventind = 0;
  338.     eventmask = 0;
  339.  
  340.     val = c1 = (*vdevice.dev.Vcheckkey)();
  341.  
  342.     c2 = (*vdevice.dev.Vlocator)(&a, &b);
  343.  
  344.     if (c1 != 0) {
  345.         eventind = c1 / 8;
  346.         eventmask = 1 << (c1 & 0x7);
  347.         if (vdevice.kbdmode) {
  348.             vdevice.data = val;
  349.             vdevice.devno = KEYBD;
  350.         } else {
  351.             vdevice.data = 1;
  352.             if (c1 >= 'a' && c1 <= 'z')
  353.                 vdevice.devno = c1 - 'a' + 'A';
  354.             else
  355.                 vdevice.devno = c1;
  356.         }
  357.     } else {
  358.         if (c2 & 0x01)
  359.             c2 = MOUSE3;
  360.         else if (c2 & 0x02)
  361.             c2 = MOUSE2;
  362.         else if (c2 & 0x04)
  363.             c2 = MOUSE1;
  364.         eventind = c2 / 8;
  365.         eventmask = 1 << (c2 & 0x7);
  366.         vdevice.data = 1;
  367.         vdevice.devno = c2;
  368.     }
  369.  
  370.     if (vdevice.enabled[eventind] & eventmask) {
  371.         vdevice.alreadyread = 1;
  372.         return(1L);
  373.     }
  374.  
  375.     return(0L);
  376. }
  377.  
  378. /*
  379.  * isqueued
  380.  *
  381.  *    return non-zero if a device is queued
  382.  */
  383. Boolean
  384. isqueued(dev)
  385.     Device    dev;
  386. {
  387.     return((long)vdevice.enabled[dev / 8] & (1 << (dev & 0x7)));
  388. }
  389.  
  390. /*
  391.  * qenter
  392.  *
  393.  *    Basically, does nothing....
  394.  */
  395. void
  396. qenter(dev, val)
  397.     Device    dev;
  398.     short    val;
  399. {
  400. }
  401.